44c267398a21fa8fa978438bb32b450e7257e2d4,src/dorkbox/util/tweenengine/BaseTween.java,BaseTween,update,#number#,545
Before Change
// will trickle-down.
// We update ALL following objects. If a tween is before start (reverse) or past end (forwards), this it will "snap" to the
// start/end endpoints
doUpdate(direction, originalDelta);
}
protected
After Change
}
currentTime = newTime;
doUpdate(FORWARDS, originalDelta);
return;
}
// we have gone past our iteration point
// adjust the delta so that it is shifted based on the length of (previous) iteration
delta = newTime - duration;
// set our currentTime for the callbacks to be accurate and updates to lock to start/end values
currentTime = duration;
// flip our state
insideDelay = true;
// make sure that we manage our children BEFORE we do anything else!
// we use originalDelta here because we have to trickle-down the logic to all children. If we use delta, the incorrect value
// will trickle-down
doUpdate(FORWARDS, originalDelta);
callCallbacks(TweenCallback.Events.END);
////////////////////////////////////////////
////////////////////////////////////////////
// 1) we are done running completely
// 2) we flip to auto-reverse repeat mode
// 3) we are in linear repeat mode
if (repeatCount <= 0) {
// {FORWARDS}{FINISHED}
// no repeats left, so we're done
// TRANSITION to finished
// really are done (so no more event notification loops)
isFinished = true;
isInAutoReverse = false;
// we're done going forwards
canTriggerBeginEvent = true;
callCallbacks(TweenCallback.Events.COMPLETE);
// now adjust the time so PARENT reversing/etc works
currentTime = duration + delta;
}
else if (canAutoReverse) {
// {FORWARDS}{AUTO_REVERSE}
repeatCount--;
// we're done going forwards
canTriggerBeginEvent = true;
isInAutoReverse = !isInAutoReverse; // if we are NOT in autoReverse, then "isInAutoReverse" is true if we reverse
this.direction = false; // make sure any checks after this returns accurately reflect the correct direction
callCallbacks(TweenCallback.Events.COMPLETE);
// setup delays, if there are any. have to adjust for any "extra" time wrapped beyond duration
currentTime = -delta;
addRepeatDelay(repeatDelay);
// has to be after addRepeatDelay()
isFinished = false;
} else {
// {FORWARDS}{LINEAR}
repeatCount--;
// have to adjust for any "extra" time wrapped beyond duration
currentTime = delta + duration;
forceRestart(-duration);
addRepeatDelay(-repeatDelay);
// have to re-put back settings, has to be after addRepeatDelay()
insideDelay = true;
isFinished = false;
isInAutoReverse = false;
}
// </editor-fold>
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
else {
// {REVERSE}
// <editor-fold>
// FORWARDS and REVERSE are different conditions
boolean insideLow = newTime > 0;
boolean insideHigh = newTime <= duration;
// check for newTime <=duration, because we can have > duration time when in a repeat-delay
if (isFinished) {
if (insideLow && insideHigh) {
// we reversed somewhere, and now should be back running again.
isFinished = false;
insideDelay = false;
triggerStartEvent = true;
}
else {
// the time that a tween/timeline runs over when it is done running, so reversing still correctly tracks delays, etc
currentTime = newTime;
doUpdate(REVERSE, originalDelta);
return;
}
}
else if (insideDelay) {
if (insideLow) {
// still inside our repeat delay, since repeat delay is always positive (going reverse)
// adjust our time
currentTime = newTime;
// return because we have to make sure that our children are updated (to preserve reversing delays/behavior)
doUpdate(REVERSE, originalDelta);
return;
} else {
// have to specify that the children should restart
delta = newTime;
newTime = duration + delta; // delta is negative here
// have to offset currentTime, so currentTime + (repeatDelay + (0)) ==> duration
currentTime = duration - repeatDelay + originalDelta;
forceRestart(0);
insideLow = true;
insideHigh = true;
canTriggerBeginEvent = true;
// continue to running normally
}
}
// we are running normally, can get here from other states
if (insideLow) {
if (insideHigh && triggerStartEvent) {
currentTime = duration; // this is reset below...
triggerStartEvent = false;
if (canTriggerBeginEvent) {
canTriggerBeginEvent = false;
callCallbacks(TweenCallback.Events.BACK_BEGIN);
}
callCallbacks(TweenCallback.Events.BACK_START);
}
currentTime = newTime;
doUpdate(REVERSE, originalDelta);
return;
}